#include <bits/stdc++.h>

using namespace std;

mt19937 mt(time(0)); // 随机数生成器

map<int, char> op; // 运算符id及其符号映射
map<int, int> pri; // 运算符id及其优先级映射
// 10表示加号   运算优先级为 0
// 11表示减号   运算优先级为 0
// 12表示乘号   运算优先级为 1
// 13表示除号   运算优先级为 1
// 14表示左括号
// 15表示右括号

// 运算数结构体，id为运算数的位置，val为运算数的值
struct node{
    int id, val;
    node(int id = -1, int val = -1):id(id), val(val){}
};

// tot：逆波兰表达式的长度，operatorNum：运算符个数
// operandNum：运算数的个数，bracketNum：括号对数，ans：运算式最终答案
// hasBracket：某个数字处是否有括号，-1表示无括号，14表示左括号，15表示右括号
// operators：对应位置的运算符种类 operands：表示对应位置运算数的值
// RPN：存储逆波兰表达式 fac：存储某个数的约数
// opr：中缀表达式转后缀表达式时的运算符栈
// opd：中缀表达式转后缀表达式时的运算数栈
// numerators：对应位置运算数的分子 denominators：对应位置运算式的分母
int tot, operatorNum, operandNum, bracketNum, ans;
int hasBracket[15], operators[15], operands[15];
int RPN[55], fac[105], numerators[15], denominators[15];
stack<int> opr;
stack<node> opd;

// 初始化函数零：初始化运算符 id 符号 以及运算优先级，并且重定向输出
void init0(){
    op[10] = '+', op[11] = '-';
    op[12] = '*';
    op[14] = '(', op[15] = ')';
    pri[10] = 0, pri[11] = 0;
    pri[12] = 1, pri[13] = 1;
    freopen("../result.txt", "w", stdout);
}

// 初始化函数一：在每次调用solve()时进行初始化
void init1(){
    tot = 0;
    for(int i = 0; i < 15; ++i){
        operators[i] = -1;
        operands[i] = -1;
        hasBracket[i] = -1;
    }
    while(!opr.empty()) opr.pop();
    while(!opd.empty()) opd.pop();
}

// 初始化函数二：在每次调用getOperands()时进行初始化
void init2(){
    tot = 0;
    while(!opr.empty()) opr.pop();
    while(!opd.empty()) opd.pop();
}

// 初始化函数三：在每次调用solve2()时进行初始化
void init3(){
    tot = 0;
    for(int i = 0; i < 15; ++i){
        operators[i] = -1;
        numerators[i] = -1;
        denominators[i] = -1;
    }
}

// 生成一个范围在 [l, r] 中的随机数
int getNum(int l, int r){
    int ret = mt()%(r - l + 1) + l;
    return ret;
}

// 获取运算数的值的函数，如果返回 true 则表示获取成功，否则表示获取失败
bool getOperands(){
    init2();
    // 将中缀表达式转换成后缀表达式（也就是逆波兰表达式）
    if(hasBracket[0] != -1) opr.push(hasBracket[0]);
    RPN[tot++] = 0;
    for(int i = 1; i < operandNum; ++i){
        while(true){
            if(opr.empty() || opr.top() == 14 || pri[operators[i - 1]] > pri[opr.top()]){
                opr.push(operators[i - 1]);
                break;
            }
            RPN[tot++] = opr.top();
            opr.pop();
        }
        if(hasBracket[i] == 14){
            opr.push(hasBracket[i]);
        }
        RPN[tot++] = i;
        if(hasBracket[i] == 15){
            while(opr.top() != 14){
                RPN[tot++] = opr.top();
                opr.pop();
            }
            opr.pop();
        }
    }
    while(!opr.empty()){
        RPN[tot++] = opr.top();
        opr.pop();
    }
    // 转换成逆波兰表达式后便可以进行尝试填数
    for(int i = 0; i < tot; ++i){
        // 如果为运算数则随机为其赋值
        if(RPN[i] < 10){
            int x = getNum(1, 66);
            operands[RPN[i]] = x;
            opd.push(node(RPN[i], x));
            continue;
        }
        //如果为除法，要将除数随机分配为被除数的一个因子
        //如果为减法，要注意减数不能大于被减数

        if(RPN[i] == 13){
            node b = opd.top(); opd.pop();
            node a = opd.top(); opd.pop();
            if(a.val%b.val == 0){
                opd.push(node(-1, a.val/b.val));
                continue;
            }
            if(b.id == -1) return false;
            int cnt = 0;
            for(int j = 1; j <= a.val; ++j){
                if(j >= 100) break;
                if(a.val%j) continue;
                fac[cnt++] = j;
            }
            int x =getNum(0, cnt - 1);
            operands[b.id] = fac[x];
            opd.push(node(-1, a.val/fac[x]));
        }else if(RPN[i] == 11){
            node b = opd.top(); opd.pop();
            node a = opd.top(); opd.pop();
            int dt = a.val - b.val;
            if(dt <= 0) return false;
            opd.push(node(-1, dt));
        }else{
            node b = opd.top(); opd.pop();
            node a = opd.top(); opd.pop();
            if(RPN[i] == 10) opd.push(node(-1, a.val + b.val));
            if(RPN[i] == 12) opd.push(node(-1, a.val*b.val));
        }
    }
    ans = opd.top().val; opd.pop();
    //控制最终运算结果的范围，可根据需要进行调节
    if(ans < 0 || ans > 1000) return false;
    return true;
}
// solve1() 表示生成普通运算式
bool solve1(bool flag){
    init1();
    // 随机生成运算符的个数 3~5 ，及运算数个数 4~6
    operatorNum = getNum(3, 5);
    operandNum = operatorNum + 1;
    // 随机生成括号个数
    bracketNum = min((int)(operandNum/2), getNum(2, 4));
    if(flag) bracketNum = 0;
    // 随机生成运算符的种类
    for(int i = 0; i < operatorNum; ++i) operators[i] = getNum(10, 13);
    // 随机生成括号位置
    for(int i = 0; i < bracketNum*2; ++i){
        int x = getNum(0, operandNum - 1);
        while(hasBracket[x] != -1) x = getNum(0, operandNum - 1);
        hasBracket[x] = 0;
    }

    // 根据相对位置确定括号为左括号还是右括号
    bool lf = true;
    for(int i = 0; i < operandNum; ++i){
        if(hasBracket[i] == -1) continue;
        if(lf) hasBracket[i] = 14;
        else hasBracket[i] = 15;
        lf = (!lf);
    }

    // 到这里已经将等式预处理成了(a+b)/c*(d-e)的类似形式
    // 预处理结束之后，我们就要尝试将 a b c d e 确定为具体的数
    if(!getOperands()) return false;

    // 在获取完运算数之后，便可以输出我们得到的等式了
    if(hasBracket[0] != -1) printf("(");
    printf("%d", operands[0]);
    for(int i = 1; i < operandNum; ++i){
        if(operators[i - 1] == 13) printf("÷");
        else printf("%c", op[operators[i - 1]]);
        if(hasBracket[i] == 14) printf("(");
        printf("%d", operands[i]);
        if(hasBracket[i] == 15) printf(")");
    }
    printf("=%d\n", ans);
    return true;
}

// solve2() 生成真分数运算式
// 由于只要求加减法，因此括号出现与否并不会影响答案
// 故solve2()中无须考虑括号与乘除号
bool solve2(){
    init3();
    operatorNum = getNum(3, 5);
    operandNum = operatorNum + 1;
    for(int i = 0; i < operatorNum; ++i) operators[i] = getNum(10, 11);
    // 生成分子与分母，保证分子严格小于分母
    denominators[0] = getNum(1, 66);
    numerators[0] = getNum(1, max(denominators[0] - 22, 1));
    int g = __gcd(numerators[0], denominators[0]);
    numerators[0] /= g, denominators[0] /= g;
    int nowNume = numerators[0], nowDeno = denominators[0];
    for(int i = 1; i < operandNum; ++i){
        denominators[i] = getNum(1, 66);
        numerators[i] =  getNum(1, max(denominators[0] - 22, 1));
        g = __gcd(numerators[i], denominators[i]);
        numerators[i] /= g, denominators[i] /= g;
        g = __gcd(denominators[i], nowDeno);
        int lcm = nowDeno*denominators[i]/g;
        nowNume *= denominators[i]/g;
        if(operators[i - 1] == 10){
            nowNume += numerators[i]*nowDeno/g;
            if(nowNume >= nowDeno) return false;
        }else if(operators[i - 1] == 11){
            nowNume -= numerators[i]*nowDeno/g;
            if(nowNume <= 0) return false;
        }
        nowDeno = lcm;
        g = __gcd(nowNume, nowDeno);
        nowNume /= g, nowDeno /= g;
        // 当运算过程中分子分母大于阈值（这里是 666 ），则重新生成算式
        if(nowNume > 666 || nowDeno > 666) return false;
    }
    printf("%d/%d", numerators[0], denominators[0]);
    for(int i = 1; i < operandNum; ++i){
        printf("%c", op[operators[i - 1]]);
        printf("%d/%d", numerators[i], denominators[i]);
    }
    printf("=%d/%d\n", nowNume, nowDeno);
    return true;
}

// 这里 x 与模数控制分数运算式出现的概率
// 这里限定为 30% 的分数运算式， 50% 的有括号普通运算式 ，20% 的无括号普通运算式
void solve(){
    int x = getNum(0, 9);
    if(x <= 2) while(!solve2()) ;
    else if(x <= 7) while(!solve1(true)) ;
    else while(!solve1(false)) ;
}

int main(){
    // 初始化函数零：初始化运算符 id 符号 以及运算优先级，并且重定向输出
    init0();
    //读入需要生成的运算式数量
    int n;
    scanf("%d", &n);
    //输出学号及运算式
    puts("2017012449");
    while(n--) solve();

    return 0;
}
